#include "clientFuncs.h"
#define PORT 8080
#define BUFSIZE (1024 * 8)

#define BLOCK_SIZE (1024 * 4) // 下载文件时每次复制的块大小：4K

/*
这个头文件是用于定义client.h中所要用到的函数
*/

/*
int getCommand(char* commandStr,char* cmd)
{
    return 1;
}
*/

void handPutsReturnData(int sockFd, char *commandStr)
{
    // 分割命令
    int tokenSize = 0;
    char **tokens = splitString(commandStr, " /", &tokenSize);
    // for (int i = 0; i < tokenSize; i++)
    // {
    //     printf("%s\n", tokens[i]);
    // }

    char file_name[50] = {0};
    strcpy(file_name, tokens[tokenSize - 1]);
    // 向服务器放送文件
    //  获得文件信息
    //  发送文件长度和名字
    int file_fd = open(file_name, O_RDWR);
    if (file_fd == -1)
    {
        perror("文件打开失败...\n");
        return;
    }
    int len = strlen(file_name);
    int ret = send(sockFd, &len, sizeof(int), 0);
    ERROR_CHECK(ret, -1, "send");
    ret = send(sockFd, file_name, len, 0);
    ERROR_CHECK(ret, -1, "send");
    // 发送文件长度
    struct stat stat_file;
    fstat(file_fd, &stat_file);
    send(sockFd, &stat_file.st_size, sizeof(off_t), MSG_NOSIGNAL);

    int Flag = 0;
    ret = recv(sockFd, &Flag, sizeof(int), MSG_WAITALL);
    ERROR_CHECK(ret, -1, "recv");

    if (Flag == 0)
    {
        printf("路径格式错误\n");
    }
    else if (Flag == 1)
    {
        printf("文件传输了一半\n");
        off_t alreadSize = 0;
        ret = recv(sockFd, &alreadSize, sizeof(off_t), MSG_WAITALL);
        lseek(file_fd, alreadSize, SEEK_SET);
        char buf[1024] = {0};
        int count = 0;
        while ((count = read(file_fd, buf, sizeof(buf))) > 0)
        {
            ret = send(sockFd, buf, count, 0);
            ERROR_CHECK(ret, -1, "send");
            if (ret <= 0)
            {
                break;
            }
            memset(buf, 0, sizeof(buf));
        }
        printf("alreadSize:%jd\n", alreadSize);
        // sendfile(sockFd, file_fd,&alreadSize, stat_file.st_size-alreadSize);
        return;
    }
    else if (Flag == 2)
    {
        printf("文件已经上传过了\n");
        return;
    }
    else
    {
        sendfile(sockFd, file_fd, NULL, stat_file.st_size);
        close(file_fd);
        printf("上传成功\n");
        return;
    }
}

void handMkdirReturnData(int sockFd)
{
    // 处理Mkdir返回来的数据
    int flag = 0;
    int ret = recv(sockFd, &flag, sizeof(int), MSG_WAITALL);
    ERROR_CHECK(ret, -1, "recv");
    if (flag == 0)
    {
        printf("创建失败\n");
        return;
    }
    printf("创建成功\n");
    return;
}

void handCdReturnData(int sockFd, clientInfo_st *st, char *commandStr)
{
    

    // flag返回值【0：失败，1：进入成功；2：当前路径(cd .)；3：退回(cd ..)】
    int flag;
    int count = recv(sockFd, &flag, 4, MSG_WAITALL);
    // count = recv(sockFd, &flag, 4, MSG_WAITALL);
    if (count == 0)
    {
        printf("服务器断开...\n");
        exit(-1);
    }
    if (flag == 4)
    {
        // 退到根
        memset(st->curPath, 0, sizeof(st->curPath));
        st->curPath[0] = '/';
        printf("cd成功..\n");
        return;
    }
    if (flag == 0)
    {
        printf("cd失败\n");
    }
    else if (flag == 1)
    {
        printf("cd成功...\n");
        // 维护客户端路径
        char *curPath = st->curPath;

        int tokenSize = 0;
        char **tokens = splitString(commandStr, " ", &tokenSize);
        if (tokens[1][0] == '/')
        {
            // 说明是全路径访问
            strcpy(st->curPath, tokens[1]);
        }
        else
        {
            // 是相对路径访问
            char clientPath[256] = {0};
            if (strlen(st->curPath) == 1)
            {
                // 说明只有根节点
                st->curPath[0] = '\0';
            }
            sprintf(clientPath, "%s/%s", st->curPath, tokens[1]);
            strcpy(st->curPath, clientPath);
        }
    }
    else if (flag == 2)
    {
        // cd .
        printf("cd成功\n");
        return;
    }
    else if (flag == 3)
    {
        printf("cd成功..\n");
        // cd ..
        char *curPath = st->curPath;
        if (strcmp(curPath, "/") == 0)
        {
            // 说明已经在根路径上
            printf("当前在根路径上,回退失败...仍处于根路径上\n");
            return;
        }
        // 说明不在根上
        int tokenSize = 0;
        char **tokens = splitString(curPath, "/", &tokenSize);
        tokens[tokenSize--] = "\0";
        char clientPath[50] = {0};
        for (int i = 0; i < tokenSize; i++)
        {
            strcat(clientPath,"/"); strcat(clientPath,tokens[i]);
            // sprintf(clientPath, "/%s", tokens[i]);
        }

        memset(st->curPath, 0, strlen(st->curPath));
        if (strlen(clientPath) == 0)
        {
            memcpy(st->curPath, "/", 1);
        }
        else
        {
            memcpy(st->curPath, clientPath, strlen(clientPath));
        }

        return;
    }
    else
    {
        printf("系统错误...退出...\n");
        exit(-1);
    }

    return;
}
// int initClientInfo(char* username,clientInfo_st* clientInfo)
// {
//     // 初始化用户名
//     memcpy(clientInfo->uname, username, strlen(username));
//     // 初始化状态
//     clientInfo->status = 1;
//     // 初始化当前路径
//     strcpy(clientInfo->curPath, "/");
//     return 1;
// }

int userLogin(const int socketFd, const char *username, const char *password)
{
    printf("socket:%d, username:%s, password:%s\n", socketFd, username, password);
    int alreadDataLen = 0; // 对于发送数据，前面拼接字符串的偏移量
    char sendBuf[1024] = {0};
    char recvBuf[1024] = {0};
    // 构造发送的数组【数据长度(占前4字节)+数据+数据长度(占前4字节)+数据】
    // 拼接username，将username的长度用4个自己放在sendBuf中
    memset(sendBuf, 0, sizeof(sendBuf));
    int usernameLen = strlen(username);
    memcpy(sendBuf + alreadDataLen, &usernameLen, 4);
    alreadDataLen += 4;
    memcpy(sendBuf + alreadDataLen, username, usernameLen);
    alreadDataLen += usernameLen;

    ////////////////可以封装一下//////////
    // 拼接password
    int passwordLen = strlen(password);
    memcpy(sendBuf + alreadDataLen, &passwordLen, 4);
    alreadDataLen += 4;
    memcpy(sendBuf + alreadDataLen, password, passwordLen);
    alreadDataLen += passwordLen;

    // 发送数据给客户端验证，用户名和密码是否正确
    send(socketFd, sendBuf, sizeof(sendBuf), 0);

    // 接收客户端对应用户名和密码发来的响应【前4个字节，1表示验证成功,0表示验证失败】
    memset(recvBuf, 0, sizeof(recvBuf));
    int count = recv(socketFd, recvBuf, sizeof(recvBuf), 0);
    if (count == 0)
    {
        printf("对端关闭...\n");
        return -1;
    }
    ////////////////////////////////////////

    int isSuccess; // 标记服务端给我的是否登录成功的响应
    memcpy(&isSuccess, recvBuf, 4);
    if (isSuccess != 1) // 登录失败
    {
        printf("用户名或密码错误，退出...\n");
        return -1;
    }

    printf("登录成功！\n");
    printf("isSuccess:%d\n", isSuccess);
    return 1;
}

int netLink(int *sock)
{
    // 通过配置文件得到服务器IP
    char server_ip[100] = {0};
    // if (getparameter("server_ip", server_ip) != 0)
    // {
    //     printf("Error: 从配置文件中无法读取正确的服务器IP.\n");
    //     return -1;
    // }
    // printf("//////////////////196\n");
    // 创建套接字
    int sockFd = socket(AF_INET, SOCK_STREAM, 0);
    *sock = sockFd;
    if (sockFd < 0)
    {
        printf("Error: Socket创建失败.\n");
        return -1;
    }

    // 连接到指定的服务器IP地址和端口
    struct sockaddr_in serv_addr;
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(PORT);
    serv_addr.sin_addr.s_addr = inet_addr("192.168.6.211");
    if (serv_addr.sin_addr.s_addr == INADDR_NONE)
    {
        printf("Error: 无效的IP或IP无法访问.\n");
        return -1;
    }

    // 尝试连接到指定的服务器地址
    if (connect(sockFd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0)
    {
        printf("Connection Failed\n");
        return -1;
    }
    return 1;
}

int initClientInfo(char *username, clientInfo_st *clientInfo)
{

    // 初始化用户名
    memcpy(clientInfo->uname, username, strlen(username));
    // 初始化状态
    clientInfo->status = 1;
    // 初始化当前路径
    strcpy(clientInfo->curPath, "/");
    return 1;
}


#define BUFSIZE (1024 * 8) // 下载文件时每次复制的块大小：8192

/*
函数作用：用于客户端处理gets命令


*/
int cHandleGets(int sockFd, char *commandStr, const char *uname, const char *curPath)
{

    // 得到文件名
    char fileName[256] = {0};
    int size;
    char *delimiters = " \t\n/";
    char **tokens = splitString(commandStr, delimiters, &size);
    // 增加对命令参数的处理，若gets命令后无有效文件参数则报错退出
    if (size == 1)
    {
        printf("需提供要下载的文件名\n");
        return -1;
    }
    strcpy(fileName, tokens[size - 1]);
    freeTokens(&tokens, size);
    // printf("文件名：%s\n", fileName);

    // 确定文件大小，本地如果已经存在该文件，则更新文件大小
    off_t localFileSize = 0;
    int destFd = open(fileName, O_RDONLY);
    if (destFd != -1)
    {
        struct stat st;
        fstat(destFd, &st);
        localFileSize = st.st_size;
        close(destFd);
    }

    // 将信息打包发送给服务器
    char LocalFileInfo[1024] = {0};
    sprintf(LocalFileInfo, "%s&%ld", fileName, localFileSize);
    send_command(sockFd, commandStr, uname, curPath, LocalFileInfo);
    // printf("发走的文件名: %s\n", fileName);
    // printf("发走的文件大小: %ld\n", localFileSize);
    // printf("%s自定义格式发送...\n", LocalFileInfo);
    // printf("下载请求已发，等待服务端回复...\n");

    // 等待服务端回复状态和状态信息
    char recvStatusMsg[1024] = {0};
    int ret = recv(sockFd, recvStatusMsg, sizeof(recvStatusMsg), MSG_WAITALL);
    if (ret == 0)
    {
        // printf("recvRet = %d\n", recvRet);
        printf("服务端断开\n");
        return -1;
    }
    if (ret == -1)
    {
        perror("recv");
        return -1;
    }

    int status = 0;
    off_t newFileSize = 0;
    // 解析recvStatusMsg  1：服务端不存在该文件  5：已有无需下载
    sscanf(recvStatusMsg, "%d&%ld", &status, &newFileSize);
    // printf("拿到状态status:%d\n", status);
    // printf("newFileSize:%ld\n", newFileSize);
    if (status == 1)
    {
        printf("目录不存在\n");
        return -1;
    }
    if (status == 2)
    {
        printf("文件不存在\n");
        return -1;
    }
    if (status == 3)
    {
        printf("服务器打开文件失败\n");
        return -1;
    }
    if (status == 5)
    {
        printf("本地已有该文件, 无需下载\n");
        return -1;
    }

    // 3：已有的文件过大，截断文件
    if (status == 7)
    {
        truncate(fileName, newFileSize);
        printf("文件大小超出，截断文件\n");
        return -1;
    }

    if (status == 8)
    {
        // 开始下载文件
        destFd = open(fileName, O_RDWR | O_CREAT |O_APPEND, 0666);
        if (destFd == -1)
        {
            printf("本地文件创建失败\n");
            return -1;
        }

<<<<<<< HEAD
        printf("还需要下载: %ld\n",  newFileSize - localFileSize);
=======
        // printf("还需要下载: %ld\n",  newFileSize - localFileSize);
>>>>>>> 9aa9cb4b0fc1115d9cdc313dfa4057dee3be96b4

        // 考虑断点续传
        // int localFileSize;   // 本地文件大小
        // off_t allFileSize;     // 总文件大小
        // off_t alreadyFileSize; // 已经读了的文件大小
        // off_t needFileSize;    // 还需要的文件大小
        // int noReadFileSize; // 还没有读的文件大小

        // localFileSize = 0;
        // allFileSize = newFileSize;
        // needFileSize = allFileSize - localFileSize;
        // alreadyFileSize = localFileSize;
        // printf("localFileSize:%ld\n", localFileSize);
        lseek(destFd, localFileSize, SEEK_SET);
        char recvBuf[BUFSIZE] = {0};
        printf("下载中...\n");
        while (1)
        {
            int count = recv(sockFd, recvBuf, sizeof(recvBuf), 0);
            if (count == 0)
                break; // 对端关闭或已经读完文件
            write(destFd, recvBuf, count);
            localFileSize += count;
            // printf("localFileSize:%ld\n", localFileSize);
            if(count < BUFSIZE) break;
        }
<<<<<<< HEAD
        printf("%s下载: %ld\n", fileName, localFileSize);

        // // mmap方式写入文件：
        // while (newFileOffset < newFileSize)
        // {
        //     printf("映射偏移：%ld\n", newFileOffset);
        //     printf("文件总大小：%ld\n", newFileSize);
        //     // 确定本次复制的字节大小
        //     // 如果已复制字节数加上一次复制的块大小超过了源文件大小，说明这是最后一次映射复制，此时只需要映射剩余文件内容就可以了
        //     // 不是最后一次映射复制，那就继续映射一整个块的大小
        //     off_t curBlockSize = (newFileSize - newFileOffset < BLOCK_SIZE) ? (newFileSize - newFileOffset) : BLOCK_SIZE;
        //     printf("curBlockSize= %ld\n", curBlockSize);
        //     // 映射目标文件
        //     char *destp =
        //         (char *)mmap(NULL, curBlockSize, PROT_READ | PROT_WRITE, MAP_SHARED, destFd, newFileOffset);
        //     if (destp == (void *)-1)
        //     {
        //         munmap(destp, curBlockSize);
        //         perror("mmap");
        //         return -1;
        //     }

        //     char buf[BLOCK_SIZE] = {0};
        //     ret = recv(sockFd, destp, curBlockSize, MSG_DONTWAIT);
        //     if (ret == 0)
        //     {
        //         printf("服务器断开连接\n");
        //         munmap(destp, curBlockSize);
        //         close(destFd);
        //         return -1;
        //     }
        //     if (ret == -1)
        //     {
        //         munmap(destp, curBlockSize);
        //         close(destFd);
        //         perror("recv");
        //         // printf("Cur socket fd: %d\n", sockFd);
        //         return -1;
        //     }
        //     // 解除映射
        //     munmap(destp, curBlockSize);
        //     // 更新已复制的字节数
        //     newFileOffset += curBlockSize;
        // }
=======
        printf("%s下载完毕,文件大小: %ld\n", fileName, localFileSize);
>>>>>>> 9aa9cb4b0fc1115d9cdc313dfa4057dee3be96b4
    }

    close(destFd);
    return 0;
}

// int cHandleGets(int sockFd, const char *commandStr, const char *uname, const char *curPath)
// {

//     // 得到文件名
//     char fileName[256] = {0};
//     int size;
//     char *delimiters = " \t\n/";
//     char **tokens = splitString(commandStr, delimiters, &size);
//     // 增加对命令参数的处理，若gets命令后无有效文件参数则报错退出
//     if (size == 1)
//     {
//         printf("需提供要下载的文件名\n");
//         return -1;
//     }
//     strcpy(fileName, tokens[size - 1]);
//     freeTokens(&tokens, size);
//     // printf("文件名：%s\n", fileName);

//     // 确定文件大小，本地如果已经存在该文件，则更新文件大小
//     off_t localFileSize = 0;
//     int destFd = open(fileName, O_RDONLY);
//     if (destFd != -1)
//     {
//         struct stat st;
//         fstat(destFd, &st);
//         localFileSize = st.st_size;
//         close(destFd);
//     }

//     // 将信息打包发送给服务器
//     char LocalFileInfo[1024] = {0};
//     sprintf(LocalFileInfo, "%s&%ld", fileName, localFileSize);
//     send_command(sockFd, commandStr, uname, curPath, LocalFileInfo);
//     printf("发走的文件名: %s\n", fileName);
//     printf("发走的文件大小: %ld\n", localFileSize);
//     printf("%s自定义格式发送...\n", LocalFileInfo);
//     printf("下载请求已发，等待服务端回复...\n");

//     // 等待服务端回复状态和状态信息
//     char recvStatusMsg[1024] = {0};
//     // recv()
//     int ret = recv(sockFd, recvStatusMsg, sizeof(recvStatusMsg), 0);
//     printf("ret:%d,\n",ret);
//     if (ret == 0)
//     {
//         // printf("recvRet = %d\n", recvRet);
//         printf("服务端断开\n");
//         return -1;
//     }
//     if (ret == -1)
//     {
//         perror("recv");
//         return -1;
//     }


//     int status = 0;
//     off_t newFileSize = 0;
//     // 解析recvStatusMsg  1：服务端不存在该文件  5：已有无需下载
//     sscanf(recvStatusMsg, "%d&%ld", &status, &newFileSize);

//     printf("status:%d\n",status);
//     // printf("status:%d\n", status);
//     // printf("newFileSize:%ld\n", newFileSize);
//     if (status == 1)
//     {
//         printf("目录不存在\n");
//         return -1;
//     }
//     if (status == 2)
//     {
//         printf("文件不存在\n");
//         return -1;
//     }
//     if (status == 3)
//     {
//         printf("服务器打开文件失败\n");
//         return -1;
//     }
//     if (status == 5)
//     {
//         printf("本地已有该文件, 无需下载\n");
//         return -1;
//     }

//     // 3：已有的文件过大，截断文件
//     if (status == 7)
//     {
//         truncate(fileName, newFileSize);
//         printf("文件大小超出，截断文件\n");
//         return -1;
//     }

//     if (status == 8)
//     {
//         // 开始下载文件
//         destFd = open(fileName, O_RDWR | O_CREAT | O_APPEND, 0666);
//         if (destFd == -1)
//         {
//             printf("本地文件创建失败\n");
//             return -1;
//         }

//         // 创建文件空洞，提前占据空间
//         int ret = ftruncate(destFd, newFileSize);
//         if (ret == -1)
//         {
//             printf("空间不足，下载失败\n");
//             close(destFd);
//             return -1;
//         }

//         // 判断客户端已有的文件大小是不是4096字节的倍数，不是的话就计算返回4096倍数，余数字节切掉重新下载
//         // off_t newFileOffset = 0;
//         printf("原偏移量：%ld\n", localFileSize);
//         if ((localFileSize % 4096) != 0)
//         {
//             localFileSize = localFileSize / 4096 * 4096;
//         }
//         printf("新偏移量：%ld\n", localFileSize);
//         printf("还需要下载: %ld\n",  newFileSize - localFileSize);

//         // 考虑断点续传
//         // int localFileSize;   // 本地文件大小
//         // off_t allFileSize;     // 总文件大小
//         // off_t alreadyFileSize; // 已经读了的文件大小
//         // off_t needFileSize;    // 还需要的文件大小
//         // int noReadFileSize; // 还没有读的文件大小

//         // localFileSize = 0;
//         // allFileSize = newFileSize;
//         // needFileSize = allFileSize - localFileSize;
//         // alreadyFileSize = localFileSize;
//         // printf("localFileSize:%ld\n", localFileSize);
//         lseek(destFd, localFileSize, SEEK_SET);
//         char recvBuf[BUFSIZE] = {0};
//         printf("下载中...\n");
//         while (1)
//         {
//             int count = recv(sockFd, recvBuf, sizeof(recvBuf), 0);
//             if (count == 0)
//                 break; // 对端关闭或已经读完文件
//             write(destFd, recvBuf, count);
//             localFileSize += count;
//             printf("count: %d, localFileSize:%ld\n", count, localFileSize);
//             if(count < BUFSIZE) break;
//         }
//         printf("%s下载完毕,文件大小: %ld\n", fileName, localFileSize);

//         // // mmap方式写入文件：
//         // while (newFileOffset < newFileSize)
//         // {
//         //     printf("映射偏移：%ld\n", newFileOffset);
//         //     printf("文件总大小：%ld\n", newFileSize);
//         //     // 确定本次复制的字节大小
//         //     // 如果已复制字节数加上一次复制的块大小超过了源文件大小，说明这是最后一次映射复制，此时只需要映射剩余文件内容就可以了
//         //     // 不是最后一次映射复制，那就继续映射一整个块的大小
//         //     off_t curBlockSize = (newFileSize - newFileOffset < BLOCK_SIZE) ? (newFileSize - newFileOffset) : BLOCK_SIZE;
//         //     printf("curBlockSize= %ld\n", curBlockSize);
//         //     // 映射目标文件
//         //     char *destp =
//         //         (char *)mmap(NULL, curBlockSize, PROT_READ | PROT_WRITE, MAP_SHARED, destFd, newFileOffset);
//         //     if (destp == (void *)-1)
//         //     {
//         //         munmap(destp, curBlockSize);
//         //         perror("mmap");
//         //         return -1;
//         //     }

//         //     char buf[BLOCK_SIZE] = {0};
//         //     ret = recv(sockFd, destp, curBlockSize, MSG_DONTWAIT);
//         //     if (ret == 0)
//         //     {
//         //         printf("服务器断开连接\n");
//         //         munmap(destp, curBlockSize);
//         //         close(destFd);
//         //         return -1;
//         //     }
//         //     if (ret == -1)
//         //     {
//         //         munmap(destp, curBlockSize);
//         //         close(destFd);
//         //         perror("recv");
//         //         // printf("Cur socket fd: %d\n", sockFd);
//         //         return -1;
//         //     }
//         //     // 解除映射
//         //     munmap(destp, curBlockSize);
//         //     // 更新已复制的字节数
//         //     newFileOffset += curBlockSize;
//         // }
//     }

//     close(destFd);
//     return 0;
// }


/*
函数作用：用于客户端处理gets命令


*/

// int cHandleGets(int sockFd, const char *commandStr, const char *uname, const char *curPath)
// {
//     // 接收文件大小
//     long serverFileSize;
//     // int fileAbsSize;
//     // char fileAbsPath[256];
//     int count = recv(sockFd, &serverFileSize, sizeof(long), MSG_WAITALL);
//     if (count == 0)
//     {
//         printf("服务端关闭...\n");
//         exit(-1);
//     }
//     // count = recv(sockFd, &fileAbsSize, 4, MSG_WAITALL); // 接收路径大小
//     // if (count == 0)
//     // {
//     //     printf("服务端关闭...\n");
//     //     exit(-1);
//     // }
//     // count = recv(sockFd, fileAbsPath, fileAbsSize, MSG_WAITALL); // 接收路径
//     // if (count == 0)
//     // {
//     //     printf("服务端关闭...\n");
//     //     exit(-1);
//     // }
//     if (serverFileSize == 0)
//     {
//         // 表示服务器没有该文件
//         printf("服务器没有该文件...\n");
//         return 1;
//     }
//     else
//     {
//         long localFileSize;
//         // 服务器有该文件
//         // 查看本地是否有该文件
//         char fileAbsPath[256]; // 假设路径不超过4096个字符
//         if (getcwd(fileAbsPath, sizeof(fileAbsPath)) != NULL)
//         {
//             printf("fileAbsPath:%s\n", fileAbsPath);
//         }
//         int tokenSize;
//         char** tokens = splitString(commandStr, " ", &tokenSize);
//         strcat(fileAbsPath,"/"); strcat(fileAbsPath,tokens[tokenSize - 1]);
//         int fileFd = open(fileAbsPath, O_RDWR | O_CREAT | O_APPEND, 0666);
//         printf("fileFd:%d\n",fileFd);

//         struct stat pstat;
//         int ret = stat(fileAbsPath, &pstat);
//         if (ret == -1)
//         {
//             // 表示本地没有该文件
//             localFileSize = 0; // 则说明要重头开始传
//         }
//         else
//         {
//             // 说明本地有文件
//             printf("文件大小:%ld\n", pstat.st_size);
//             localFileSize = pstat.st_size;
//         }
//         send(sockFd, &localFileSize, sizeof(long), 0); // 发送本地文件大小过去

//         // 文件偏移
//         lseek(fileFd, localFileSize, SEEK_SET);

        
//         // 接收文件
//         char recvBuf[1024 * 16];
//         long totalFileSize = serverFileSize;
//         long alreadExistFileSize = localFileSize;
//         long remainFileSize = totalFileSize - alreadExistFileSize;
//         while (1)
//         {
//             printf("remainFileSize:%ld\n", remainFileSize);
//             if (remainFileSize == 0)
//             {
//                 printf("传输完毕...\n");
//                 break;
//             }
//             int count;
//             if (remainFileSize >= sizeof(recvBuf))
//             {
//                 count = recv(sockFd, recvBuf, sizeof(recvBuf), MSG_WAITALL);
//             }
//             else
//             {
//                 count = recv(sockFd, recvBuf, remainFileSize, MSG_WAITALL);
//             }
//             write(fileFd, recvBuf, count);
//             alreadExistFileSize += count;
//             remainFileSize = totalFileSize - alreadExistFileSize;
//         }
//         printf("localFileSize:%ld",localFileSize);
//         close(fileFd);
//     }
//     return 1;
// }
